﻿//using System;
//using System.Collections;
//using System.Collections.Generic;
//using System.Configuration;
//using System.Diagnostics;
//using System.Linq;
//using System.Runtime.ConstrainedExecution;
//using System.Runtime.Serialization;
//using System.Security.Permissions;
//using System.Text;
//using BlobNet.Base.Base;
//using BlobNet.Base.DataProviders;
//using BlobNet.Base.Interfaces;
//using BlobNet.Base.Storage;
//using System.Threading;

//namespace BlobNet.Base.Collections
//{
//    [DebuggerDisplay("Count = {Count}")]
//    //TODO:quit comment [DebuggerStepThrough]
//    [Serializable]
//    internal class ShPersistentDictionary<TKey, TValue> : ShCollectionBase,
//        IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback
//    {
//        #region Constructors

//        internal ShDictionary(BlobDomain blobDomain, IShDataProvider dataProvider, Guid collectionId)
//            : base(blobDomain, dataProvider, collectionId)
//        { }

//        public ShDictionary(BlobDomain blobDomain, Guid collectionId)
//            : base(blobDomain, collectionId)
//        { }

//        internal ShDictionary(BlobDomain blobDomain, Guid collectionId, IShDataProvider dataProvider)
//            : base(blobDomain, dataProvider, collectionId)
//        { }

//        public ShDictionary(BlobDomain blobDomain, Guid collectionId, IShDataProvider dataProvider, IDictionary<TKey, TValue> source)
//            : this(blobDomain, collectionId, dataProvider)
//        {
//            foreach (var key in source.Keys)
//            {
//                Add(key, source[key]);
//            }
//        }

//        public ShDictionary(BlobDomain blobDomain, Guid collectionId, IDictionary<TKey, TValue> source)
//            : this(blobDomain, collectionId, ShDataProviderFactory.Provider, source)
//        { }


//        public ShDictionary(BlobDomain blobDomain, Guid collectionId, IEqualityComparer<TKey> comparer):this(blobDomain,collectionId)
//        {

//            if (comparer == null)
//                comparer = (IEqualityComparer<TKey>)EqualityComparer<TKey>.Default;
//            this.comparer = comparer;
//        }


//        #endregion Constructors


//        private int[] buckets;
//        private ShDictionary<TKey, TValue>.Entry[] entries;
//        private int count;
//        private int version;
//        private int freeList;
//        private int freeCount;
//        private IEqualityComparer<TKey> comparer;
//        private ShDictionary<TKey, TValue>.KeyCollection keys;
//        private ShDictionary<TKey, TValue>.ValueCollection values;
//        private object _syncRoot;
//        private SerializationInfo m_siInfo;

//        public IEqualityComparer<TKey> Comparer
//        {
//            get
//            {
//                return this.comparer;
//            }
//        }

//        public int Count
//        {
//            get
//            {
//                return this.count - this.freeCount;
//            }
//        }

//        public ShDictionary<TKey, TValue>.KeyCollection Keys
//        {
//            get
//            {
//                if (this.keys == null)
//                    this.keys = new ShDictionary<TKey, TValue>.KeyCollection(this);
//                return this.keys;
//            }
//        }

//        ICollection<TKey> IDictionary<TKey, TValue>.Keys
//        {
//            get
//            {
//                if (this.keys == null)
//                    this.keys = new ShDictionary<TKey, TValue>.KeyCollection(this);
//                return (ICollection<TKey>)this.keys;
//            }
//        }

//        public ShDictionary<TKey, TValue>.ValueCollection Values
//        {
//            get
//            {
//                if (this.values == null)
//                    this.values = new ShDictionary<TKey, TValue>.ValueCollection(this);
//                return this.values;
//            }
//        }

//        ICollection<TValue> IDictionary<TKey, TValue>.Values
//        {
//            get
//            {
//                if (this.values == null)
//                    this.values = new ShDictionary<TKey, TValue>.ValueCollection(this);
//                return (ICollection<TValue>)this.values;
//            }
//        }

//        public TValue this[TKey key]
//        {
//            get
//            {
//                int entry = this.FindEntry(key);
//                if (entry < 0) throw new KeyNotFoundException();
//                return this.entries[entry].value;
//            }
//            set
//            {
//                this.Insert(key, value, false);
//            }
//        }

//        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
//        {
//            get
//            {
//                return false;
//            }
//        }

//        bool ICollection.IsSynchronized
//        {
//            get
//            {
//                return false;
//            }
//        }

//        object ICollection.SyncRoot
//        {
//            get
//            {
//                if (this._syncRoot == null)
//                    Interlocked.CompareExchange(ref this._syncRoot, new object(), (object)null);
//                return this._syncRoot;
//            }
//        }

//        bool IDictionary.IsFixedSize
//        {
//            get
//            {
//                return false;
//            }
//        }

//        bool IDictionary.IsReadOnly
//        {
//            get
//            {
//                return false;
//            }
//        }

//        ICollection IDictionary.Keys
//        {
//            get
//            {
//                return (ICollection)this.Keys;
//            }
//        }

//        ICollection IDictionary.Values
//        {
//            get
//            {
//                return (ICollection)this.Values;
//            }
//        }


//        public void Add(TKey key, TValue value)
//        {
//            this.Insert(key, value, true);
//        }

//        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> keyValuePair)
//        {
//            this.Add(keyValuePair.Key, keyValuePair.Value);
//        }

//        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair)
//        {
//            int entry = this.FindEntry(keyValuePair.Key);
//            if (entry >= 0 && EqualityComparer<TValue>.Default.Equals(this.entries[entry].value, keyValuePair.Value))
//                return true;
//            else
//                return false;
//        }

//        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair)
//        {
//            int entry = this.FindEntry(keyValuePair.Key);
//            if (entry < 0 || !EqualityComparer<TValue>.Default.Equals(this.entries[entry].value, keyValuePair.Value))
//                return false;
//            this.Remove(keyValuePair.Key);
//            return true;
//        }

//        public void Clear()
//        {
//            if (this.count <= 0)
//                return;
//            for (int index = 0; index < this.buckets.Length; ++index)
//                this.buckets[index] = -1;
//            Array.Clear((Array)this.entries, 0, this.count);
//            this.freeList = -1;
//            this.count = 0;
//            this.freeCount = 0;
//            ++this.version;
//        }

//        public bool ContainsKey(TKey key)
//        {
//            return this.FindEntry(key) >= 0;
//        }

//        public bool ContainsValue(TValue value)
//        {
//            if ((object)value == null)
//            {
//                for (int index = 0; index < this.count; ++index)
//                {
//                    if (this.entries[index].hashCode >= 0 && (object)this.entries[index].value == null)
//                        return true;
//                }
//            }
//            else
//            {
//                EqualityComparer<TValue> @default = EqualityComparer<TValue>.Default;
//                for (int index = 0; index < this.count; ++index)
//                {
//                    if (this.entries[index].hashCode >= 0 && @default.Equals(this.entries[index].value, value))
//                        return true;
//                }
//            }
//            return false;
//        }

//        private void CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
//        {
//            if (array == null)
//                throw new ArgumentNullException();
//            if (index < 0 || index > array.Length)
//                throw new ArgumentOutOfRangeException();
//            if (array.Length - index < this.Count)
//                throw new ArgumentException();
//            int num = this.count;
//            ShDictionary<TKey, TValue>.Entry[] entryArray = this.entries;
//            for (int index1 = 0; index1 < num; ++index1)
//            {
//                if (entryArray[index1].hashCode >= 0)
//                    array[index++] = new KeyValuePair<TKey, TValue>(entryArray[index1].key, entryArray[index1].value);
//            }
//        }

//        public ShDictionary<TKey, TValue>.Enumerator GetEnumerator()
//        {
//            return new ShDictionary<TKey, TValue>.Enumerator(this, 2);
//        }

//        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
//        {
//            return (IEnumerator<KeyValuePair<TKey, TValue>>)new ShDictionary<TKey, TValue>.Enumerator(this, 2);
//        }

//        [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
//        public virtual void GetObjectData(SerializationInfo info, StreamingBlobDomain blobDomain)
//        {
//            if (info == null)
//                throw new ArgumentNullException("info");
//            info.AddValue("Version", this.version);
//            info.AddValue("Comparer", (object)this.comparer, typeof(IEqualityComparer<TKey>));
//            info.AddValue("HashSize", this.buckets == null ? 0 : this.buckets.Length);
//            if (this.buckets == null)
//                return;
//            KeyValuePair<TKey, TValue>[] array = new KeyValuePair<TKey, TValue>[this.Count];
//            this.CopyTo(array, 0);
//            info.AddValue("KeyValuePairs", (object)array, typeof(KeyValuePair<TKey, TValue>[]));
//        }

//        private int FindEntry(TKey key)
//        {
//            if ((object)key == null)
//                throw new ArgumentNullException("key");
//            if (this.buckets != null)
//            {
//                int num = this.comparer.GetHashCode(key) & int.MaxValue;
//                for (int index = this.buckets[num % this.buckets.Length]; index >= 0; index = this.entries[index].next)
//                {
//                    if (this.entries[index].hashCode == num && this.comparer.Equals(this.entries[index].key, key))
//                        return index;
//                }
//            }
//            return -1;
//        }

//        private void Initialize(int capacity)
//        {
//            int prime = HashHelpers.GetPrime(capacity);
//            this.buckets = new int[prime];
//            for (int index = 0; index < this.buckets.Length; ++index)
//                this.buckets[index] = -1;
//            this.entries = new ShDictionary<TKey, TValue>.Entry[prime];
//            this.freeList = -1;
//        }

//        private void Insert(TKey key, TValue value, bool add)
//        {
//            if ((object)key == null)
//                throw new ArgumentNullException("key");
//            if (this.buckets == null)
//                this.Initialize(0);
//            int num = this.comparer.GetHashCode(key) & int.MaxValue;
//            int index1 = num % this.buckets.Length;
//            for (int index2 = this.buckets[index1]; index2 >= 0; index2 = this.entries[index2].next)
//            {
//                if (this.entries[index2].hashCode == num && this.comparer.Equals(this.entries[index2].key, key))
//                {
//                    if (add)
//                        throw new ArgumentException("Duplicated key");
//                    this.entries[index2].value = value;
//                    ++this.version;
//                    return;
//                }
//            }
//            int index3;
//            if (this.freeCount > 0)
//            {
//                index3 = this.freeList;
//                this.freeList = this.entries[index3].next;
//                --this.freeCount;
//            }
//            else
//            {
//                if (this.count == this.entries.Length)
//                {
//                    this.Resize();
//                    index1 = num % this.buckets.Length;
//                }
//                index3 = this.count;
//                ++this.count;
//            }
//            this.entries[index3].hashCode = num;
//            this.entries[index3].next = this.buckets[index1];
//            this.entries[index3].key = key;
//            this.entries[index3].value = value;
//            this.buckets[index1] = index3;
//            ++this.version;
//        }

//        public virtual void OnDeserialization(object sender)
//        {
//            if (this.m_siInfo == null)
//                return;
//            int int32_1 = this.m_siInfo.GetInt32("Version");
//            int int32_2 = this.m_siInfo.GetInt32("HashSize");
//            this.comparer = (IEqualityComparer<TKey>)this.m_siInfo.GetValue("Comparer", typeof(IEqualityComparer<TKey>));
//            if (int32_2 != 0)
//            {
//                this.buckets = new int[int32_2];
//                for (int index = 0; index < this.buckets.Length; ++index)
//                    this.buckets[index] = -1;
//                this.entries = new ShDictionary<TKey, TValue>.Entry[int32_2];
//                this.freeList = -1;
//                KeyValuePair<TKey, TValue>[] keyValuePairArray = (KeyValuePair<TKey, TValue>[])this.m_siInfo.GetValue("KeyValuePairs", typeof(KeyValuePair<TKey, TValue>[]));
//                if (keyValuePairArray == null)
//                    throw new SerializationException("Missing Key/value pair");
//                for (int index = 0; index < keyValuePairArray.Length; ++index)
//                {
//                    if ((object)keyValuePairArray[index].Key == null)
//                        throw new SerializationException("Key is null");
//                    this.Insert(keyValuePairArray[index].Key, keyValuePairArray[index].Value, true);
//                }
//            }
//            else
//                this.buckets = (int[])null;
//            this.version = int32_1;
//            this.m_siInfo = (SerializationInfo)null;
//        }

//        private void Resize()
//        {
//            int prime = HashHelpers.GetPrime(this.count * 2);
//            int[] numArray = new int[prime];
//            for (int index = 0; index < numArray.Length; ++index)
//                numArray[index] = -1;
//            ShDictionary<TKey, TValue>.Entry[] entryArray = new ShDictionary<TKey, TValue>.Entry[prime];
//            Array.Copy((Array)this.entries, 0, (Array)entryArray, 0, this.count);
//            for (int index1 = 0; index1 < this.count; ++index1)
//            {
//                int index2 = entryArray[index1].hashCode % prime;
//                entryArray[index1].next = numArray[index2];
//                numArray[index2] = index1;
//            }
//            this.buckets = numArray;
//            this.entries = entryArray;
//        }

//        public bool Remove(TKey key)
//        {
//            if ((object)key == null)
//                throw new ArgumentNullException("key");
//            if (this.buckets != null)
//            {
//                int num = this.comparer.GetHashCode(key) & int.MaxValue;
//                int index1 = num % this.buckets.Length;
//                int index2 = -1;
//                for (int index3 = this.buckets[index1]; index3 >= 0; index3 = this.entries[index3].next)
//                {
//                    if (this.entries[index3].hashCode == num && this.comparer.Equals(this.entries[index3].key, key))
//                    {
//                        if (index2 < 0)
//                            this.buckets[index1] = this.entries[index3].next;
//                        else
//                            this.entries[index2].next = this.entries[index3].next;
//                        this.entries[index3].hashCode = -1;
//                        this.entries[index3].next = this.freeList;
//                        this.entries[index3].key = default(TKey);
//                        this.entries[index3].value = default(TValue);
//                        this.freeList = index3;
//                        ++this.freeCount;
//                        ++this.version;
//                        return true;
//                    }
//                    else
//                        index2 = index3;
//                }
//            }
//            return false;
//        }

//        public bool TryGetValue(TKey key, out TValue value)
//        {
//            int entry = this.FindEntry(key);
//            if (entry >= 0)
//            {
//                value = this.entries[entry].value;
//                return true;
//            }
//            else
//            {
//                value = default(TValue);
//                return false;
//            }
//        }

//        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
//        {
//            this.CopyTo(array, index);
//        }

//        void ICollection.CopyTo(Array array, int index)
//        {
//            if (array == null)
//                throw new ArgumentNullException("array");
//            if (array.Rank != 1)
//                throw new ArgumentException("Multirank not supported");
//            if (array.GetLowerBound(0) != 0)
//                throw new ArgumentException("lower bound must be zero");
//            if (index < 0 || index > array.Length)
//                throw new ArgumentOutOfRangeException();
//            if (array.Length - index < this.Count)
//                throw new ArgumentException();
//            KeyValuePair<TKey, TValue>[] array1 = array as KeyValuePair<TKey, TValue>[];
//            if (array1 != null)
//                this.CopyTo(array1, index);
//            else if (array is DictionaryEntry[])
//            {
//                DictionaryEntry[] dictionaryEntryArray = array as DictionaryEntry[];
//                ShDictionary<TKey, TValue>.Entry[] entryArray = this.entries;
//                for (int index1 = 0; index1 < this.count; ++index1)
//                {
//                    if (entryArray[index1].hashCode >= 0)
//                        dictionaryEntryArray[index++] = new DictionaryEntry((object)entryArray[index1].key, (object)entryArray[index1].value);
//                }
//            }
//            else
//            {
//                object[] objArray = array as object[];
//                if (objArray == null)
//                    throw new ArgumentException("Invalid array");
//                try
//                {
//                    int num = this.count;
//                    ShDictionary<TKey, TValue>.Entry[] entryArray = this.entries;
//                    for (int index1 = 0; index1 < num; ++index1)
//                    {
//                        if (entryArray[index1].hashCode >= 0)
//                            objArray[index++] = (object)new KeyValuePair<TKey, TValue>(entryArray[index1].key, entryArray[index1].value);
//                    }
//                }
//                catch (ArrayTypeMismatchException ex)
//                {
//                    throw new ArgumentException("Invalid Array Type");
//                }
//            }
//        }

//        IEnumerator IEnumerable.GetEnumerator()
//        {
//            return (IEnumerator)new ShDictionary<TKey, TValue>.Enumerator(this, 2);
//        }

//        object IDictionary.this[object key]
//        {
//            get
//            {
//                if (ShDictionary<TKey, TValue>.IsCompatibleKey(key))
//                {
//                    int entry = this.FindEntry((TKey)key);
//                    if (entry >= 0)
//                        return (object)this.entries[entry].value;
//                }
//                return (object)null;
//            }
//            set
//            {
//                ShDictionary<TKey, TValue>.VerifyKey(key);
//                ShDictionary<TKey, TValue>.VerifyValueType(value);
//                this[(TKey)key] = (TValue)value;
//            }
//        }


//        private static void VerifyKey(object key)
//        {
//            if (key == null)
//                throw new ArgumentNullException("key");
//            if (key is TKey)
//                return;
//            throw new ArgumentException( "key");
//        }

//        private static bool IsCompatibleKey(object key)
//        {
//            if (key == null)
//                throw new ArgumentNullException("key");
//            return key is TKey;
//        }

//        private static void VerifyValueType(object value)
//        {
//            if (value is TValue || value == null && !typeof(TValue).IsValueType)
//                return;
//            throw new ArgumentNullException("value");
//        }

//        void IDictionary.Add(object key, object value)
//        {
//            ShDictionary<TKey, TValue>.VerifyKey(key);
//            ShDictionary<TKey, TValue>.VerifyValueType(value);
//            this.Add((TKey)key, (TValue)value);
//        }

//        bool IDictionary.Contains(object key)
//        {
//            if (ShDictionary<TKey, TValue>.IsCompatibleKey(key))
//                return this.ContainsKey((TKey)key);
//            else
//                return false;
//        }

//        IDictionaryEnumerator IDictionary.GetEnumerator()
//        {
//            return (IDictionaryEnumerator)new ShDictionary<TKey, TValue>.Enumerator(this, 1);
//        }

//        void IDictionary.Remove(object key)
//        {
//            if (!ShDictionary<TKey, TValue>.IsCompatibleKey(key))
//                return;
//            this.Remove((TKey)key);
//        }

//        private struct Entry
//        {
//            public int hashCode;
//            public int next;
//            public TKey key;
//            public TValue value;
//        }

//        [Serializable]
//        public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IDisposable, IDictionaryEnumerator, IEnumerator
//        {
//            internal const int DictEntry = 1;
//            internal const int KeyValuePair = 2;
//            private ShDictionary<TKey, TValue> dictionary;
//            private int version;
//            private int index;
//            private KeyValuePair<TKey, TValue> current;
//            private int getEnumeratorRetType;

//            public KeyValuePair<TKey, TValue> Current
//            {
//                get
//                {
//                    return this.current;
//                }
//            }

//            object IEnumerator.Current
//            {
//                get
//                {
//                    if (this.index == 0 || this.index == this.dictionary.count + 1)
//                        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
//                    if (this.getEnumeratorRetType == 1)
//                        return (object)new DictionaryEntry((object)this.current.Key, (object)this.current.Value);
//                    else
//                        return (object)new KeyValuePair<TKey, TValue>(this.current.Key, this.current.Value);
//                }
//            }

//            DictionaryEntry IDictionaryEnumerator.Entry
//            {
//                get
//                {
//                    if (this.index == 0 || this.index == this.dictionary.count + 1)
//                        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
//                    return new DictionaryEntry((object)this.current.Key, (object)this.current.Value);
//                }
//            }

//            object IDictionaryEnumerator.Key
//            {
//                get
//                {
//                    if (this.index == 0 || this.index == this.dictionary.count + 1)
//                        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
//                    return (object)this.current.Key;
//                }
//            }

//            object IDictionaryEnumerator.Value
//            {
//                get
//                {
//                    if (this.index == 0 || this.index == this.dictionary.count + 1)
//                        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
//                    return (object)this.current.Value;
//                }
//            }

//            internal Enumerator(ShDictionary<TKey, TValue> dictionary, int getEnumeratorRetType)
//            {
//                this.dictionary = dictionary;
//                this.version = dictionary.version;
//                this.index = 0;
//                this.getEnumeratorRetType = getEnumeratorRetType;
//                this.current = new KeyValuePair<TKey, TValue>();
//            }

//            public bool MoveNext()
//            {
//                if (this.version != this.dictionary.version)
//                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
//                for (; (uint)this.index < (uint)this.dictionary.count; ++this.index)
//                {
//                    if (this.dictionary.entries[this.index].hashCode >= 0)
//                    {
//                        this.current = new KeyValuePair<TKey, TValue>(this.dictionary.entries[this.index].key, this.dictionary.entries[this.index].value);
//                        ++this.index;
//                        return true;
//                    }
//                }
//                this.index = this.dictionary.count + 1;
//                this.current = new KeyValuePair<TKey, TValue>();
//                return false;
//            }

//            public void Dispose()
//            {
//            }

//            void IEnumerator.Reset()
//            {
//                if (this.version != this.dictionary.version)
//                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
//                this.index = 0;
//                this.current = new KeyValuePair<TKey, TValue>();
//            }
//        }

//        [DebuggerTypeProxy(typeof(Mscorlib_DictionaryKeyCollectionDebugView<,>))]
//        [DebuggerDisplay("Count = {Count}")]
//        [Serializable]
//        public sealed class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, ICollection, IEnumerable
//        {
//            private ShDictionary<TKey, TValue> dictionary;

//            public int Count
//            {
//                get
//                {
//                    return this.dictionary.Count;
//                }
//            }

//            bool ICollection<TKey>.IsReadOnly
//            {
//                get
//                {
//                    return true;
//                }
//            }

//            bool ICollection.IsSynchronized
//            {
//                get
//                {
//                    return false;
//                }
//            }

//            object ICollection.SyncRoot
//            {
//                get
//                {
//                    return this.dictionary.SyncRoot;
//                }
//            }

//            public KeyCollection(ShDictionary<TKey, TValue> dictionary)
//            {
//                if (dictionary == null)
//                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
//                this.dictionary = dictionary;
//            }

//            public ShDictionary<TKey, TValue>.KeyCollection.Enumerator GetEnumerator()
//            {
//                return new ShDictionary<TKey, TValue>.KeyCollection.Enumerator(this.dictionary);
//            }

//            public void CopyTo(TKey[] array, int index)
//            {
//                if (array == null)
//                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
//                if (index < 0 || index > array.Length)
//                    ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
//                if (array.Length - index < this.dictionary.Count)
//                    throw new ArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
//                int num = this.dictionary.count;
//                ShDictionary<TKey, TValue>.Entry[] entryArray = this.dictionary.entries;
//                for (int index1 = 0; index1 < num; ++index1)
//                {
//                    if (entryArray[index1].hashCode >= 0)
//                        array[index++] = entryArray[index1].key;
//                }
//            }

//            void ICollection<TKey>.Add(TKey item)
//            {
//                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
//            }

//            void ICollection<TKey>.Clear()
//            {
//                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
//            }

//            bool ICollection<TKey>.Contains(TKey item)
//            {
//                return this.dictionary.ContainsKey(item);
//            }

//            bool ICollection<TKey>.Remove(TKey item)
//            {
//                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
//                return false;
//            }

//            IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator()
//            {
//                return (IEnumerator<TKey>)new ShDictionary<TKey, TValue>.KeyCollection.Enumerator(this.dictionary);
//            }

//            IEnumerator IEnumerable.GetEnumerator()
//            {
//                return (IEnumerator)new ShDictionary<TKey, TValue>.KeyCollection.Enumerator(this.dictionary);
//            }

//            void ICollection.CopyTo(Array array, int index)
//            {
//                if (array == null)
//                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
//                if (array.Rank != 1)
//                    throw new ArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
//                if (array.GetLowerBound(0) != 0)
//                    throw new ArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
//                if (index < 0 || index > array.Length)
//                    ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
//                if (array.Length - index < this.dictionary.Count)
//                    throw new ArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
//                TKey[] array1 = array as TKey[];
//                if (array1 != null)
//                {
//                    this.CopyTo(array1, index);
//                }
//                else
//                {
//                    object[] objArray = array as object[];
//                    if (objArray == null)
//                        throw new ArgumentException(ExceptionResource.Argument_InvalidArrayType);
//                    int num = this.dictionary.count;
//                    ShDictionary<TKey, TValue>.Entry[] entryArray = this.dictionary.entries;
//                    try
//                    {
//                        for (int index1 = 0; index1 < num; ++index1)
//                        {
//                            if (entryArray[index1].hashCode >= 0)
//                                objArray[index++] = (object)entryArray[index1].key;
//                        }
//                    }
//                    catch (ArrayTypeMismatchException ex)
//                    {
//                        throw new ArgumentException(ExceptionResource.Argument_InvalidArrayType);
//                    }
//                }
//            }

//            [Serializable]
//            public struct Enumerator : IEnumerator<TKey>, IDisposable, IEnumerator
//            {
//                private ShDictionary<TKey, TValue> dictionary;
//                private int index;
//                private int version;
//                private TKey currentKey;

//                public TKey Current
//                {
//                    get
//                    {
//                        return this.currentKey;
//                    }
//                }

//                object IEnumerator.Current
//                {
//                    get
//                    {
//                        if (this.index == 0 || this.index == this.dictionary.count + 1)
//                            ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
//                        return (object)this.currentKey;
//                    }
//                }

//                internal Enumerator(ShDictionary<TKey, TValue> dictionary)
//                {
//                    this.dictionary = dictionary;
//                    this.version = dictionary.version;
//                    this.index = 0;
//                    this.currentKey = default(TKey);
//                }

//                public void Dispose()
//                {
//                }

//                public bool MoveNext()
//                {
//                    if (this.version != this.dictionary.version)
//                        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
//                    for (; (uint)this.index < (uint)this.dictionary.count; ++this.index)
//                    {
//                        if (this.dictionary.entries[this.index].hashCode >= 0)
//                        {
//                            this.currentKey = this.dictionary.entries[this.index].key;
//                            ++this.index;
//                            return true;
//                        }
//                    }
//                    this.index = this.dictionary.count + 1;
//                    this.currentKey = default(TKey);
//                    return false;
//                }

//                void IEnumerator.Reset()
//                {
//                    if (this.version != this.dictionary.version)
//                        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
//                    this.index = 0;
//                    this.currentKey = default(TKey);
//                }
//            }
//        }

//        [DebuggerTypeProxy(typeof(Mscorlib_DictionaryValueCollectionDebugView<,>))]
//        [DebuggerDisplay("Count = {Count}")]
//        [Serializable]
//        public sealed class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, ICollection, IEnumerable
//        {
//            private ShDictionary<TKey, TValue> dictionary;

//            public int Count
//            {
//                get
//                {
//                    return this.dictionary.Count;
//                }
//            }

//            bool ICollection<TValue>.IsReadOnly
//            {
//                get
//                {
//                    return true;
//                }
//            }

//            bool ICollection.IsSynchronized
//            {
//                get
//                {
//                    return false;
//                }
//            }

//            object ICollection.SyncRoot
//            {
//                get
//                {
//                    return this.dictionary.SyncRoot;
//                }
//            }

//            public ValueCollection(ShDictionary<TKey, TValue> dictionary)
//            {
//                if (dictionary == null)
//                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
//                this.dictionary = dictionary;
//            }

//            public ShDictionary<TKey, TValue>.ValueCollection.Enumerator GetEnumerator()
//            {
//                return new ShDictionary<TKey, TValue>.ValueCollection.Enumerator(this.dictionary);
//            }

//            public void CopyTo(TValue[] array, int index)
//            {
//                if (array == null)
//                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
//                if (index < 0 || index > array.Length)
//                    ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
//                if (array.Length - index < this.dictionary.Count)
//                    throw new ArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
//                int num = this.dictionary.count;
//                ShDictionary<TKey, TValue>.Entry[] entryArray = this.dictionary.entries;
//                for (int index1 = 0; index1 < num; ++index1)
//                {
//                    if (entryArray[index1].hashCode >= 0)
//                        array[index++] = entryArray[index1].value;
//                }
//            }

//            void ICollection<TValue>.Add(TValue item)
//            {
//                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
//            }

//            bool ICollection<TValue>.Remove(TValue item)
//            {
//                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
//                return false;
//            }

//            void ICollection<TValue>.Clear()
//            {
//                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
//            }

//            bool ICollection<TValue>.Contains(TValue item)
//            {
//                return this.dictionary.ContainsValue(item);
//            }

//            IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator()
//            {
//                return (IEnumerator<TValue>)new ShDictionary<TKey, TValue>.ValueCollection.Enumerator(this.dictionary);
//            }

//            IEnumerator IEnumerable.GetEnumerator()
//            {
//                return (IEnumerator)new ShDictionary<TKey, TValue>.ValueCollection.Enumerator(this.dictionary);
//            }

//            void ICollection.CopyTo(Array array, int index)
//            {
//                if (array == null)
//                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
//                if (array.Rank != 1)
//                    throw new ArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
//                if (array.GetLowerBound(0) != 0)
//                    throw new ArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
//                if (index < 0 || index > array.Length)
//                    ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
//                if (array.Length - index < this.dictionary.Count)
//                    throw new ArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
//                TValue[] array1 = array as TValue[];
//                if (array1 != null)
//                {
//                    this.CopyTo(array1, index);
//                }
//                else
//                {
//                    object[] objArray = array as object[];
//                    if (objArray == null)
//                        throw new ArgumentException(ExceptionResource.Argument_InvalidArrayType);
//                    int num = this.dictionary.count;
//                    ShDictionary<TKey, TValue>.Entry[] entryArray = this.dictionary.entries;
//                    try
//                    {
//                        for (int index1 = 0; index1 < num; ++index1)
//                        {
//                            if (entryArray[index1].hashCode >= 0)
//                                objArray[index++] = (object)entryArray[index1].value;
//                        }
//                    }
//                    catch (ArrayTypeMismatchException ex)
//                    {
//                        throw new ArgumentException(ExceptionResource.Argument_InvalidArrayType);
//                    }
//                }
//            }

//            private static class HashHelpers
//            {
//                internal static readonly int[] primes = new int[72]
//    {
//      3,
//      7,
//      11,
//      17,
//      23,
//      29,
//      37,
//      47,
//      59,
//      71,
//      89,
//      107,
//      131,
//      163,
//      197,
//      239,
//      293,
//      353,
//      431,
//      521,
//      631,
//      761,
//      919,
//      1103,
//      1327,
//      1597,
//      1931,
//      2333,
//      2801,
//      3371,
//      4049,
//      4861,
//      5839,
//      7013,
//      8419,
//      10103,
//      12143,
//      14591,
//      17519,
//      21023,
//      25229,
//      30293,
//      36353,
//      43627,
//      52361,
//      62851,
//      75431,
//      90523,
//      108631,
//      130363,
//      156437,
//      187751,
//      225307,
//      270371,
//      324449,
//      389357,
//      467237,
//      560689,
//      672827,
//      807403,
//      968897,
//      1162687,
//      1395263,
//      1674319,
//      2009191,
//      2411033,
//      2893249,
//      3471899,
//      4166287,
//      4999559,
//      5999471,
//      7199369
//    };

//                static HashHelpers()
//                {
//                }

//                [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
//                internal static bool IsPrime(int candidate)
//                {
//                    if ((candidate & 1) == 0)
//                        return candidate == 2;
//                    int num1 = (int)Math.Sqrt((double)candidate);
//                    int num2 = 3;
//                    while (num2 <= num1)
//                    {
//                        if (candidate % num2 == 0)
//                            return false;
//                        num2 += 2;
//                    }
//                    return true;
//                }

//                [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
//                internal static int GetPrime(int min)
//                {
//                    if (min < 0)
//                        throw new ArgumentException();
//                    for (int index = 0; index < HashHelpers.primes.Length; ++index)
//                    {
//                        int num = HashHelpers.primes[index];
//                        if (num >= min)
//                            return num;
//                    }
//                    int candidate = min | 1;
//                    while (candidate < int.MaxValue)
//                    {
//                        if (HashHelpers.IsPrime(candidate))
//                            return candidate;
//                        candidate += 2;
//                    }
//                    return min;
//                }
//            }

//            [Serializable]
//            public struct Enumerator : IEnumerator<TValue>, IDisposable, IEnumerator
//            {
//                private ShDictionary<TKey, TValue> dictionary;
//                private int index;
//                private int version;
//                private TValue currentValue;

//                public TValue Current
//                {
//                    get
//                    {
//                        return this.currentValue;
//                    }
//                }

//                object IEnumerator.Current
//                {
//                    get
//                    {
//                        if (this.index == 0 || this.index == this.dictionary.count + 1)
//                            ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
//                        return (object)this.currentValue;
//                    }
//                }

//                internal Enumerator(ShDictionary<TKey, TValue> dictionary)
//                {
//                    this.dictionary = dictionary;
//                    this.version = dictionary.version;
//                    this.index = 0;
//                    this.currentValue = default(TValue);
//                }

//                public void Dispose()
//                {
//                }

//                public bool MoveNext()
//                {
//                    if (this.version != this.dictionary.version)
//                        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
//                    for (; (uint)this.index < (uint)this.dictionary.count; ++this.index)
//                    {
//                        if (this.dictionary.entries[this.index].hashCode >= 0)
//                        {
//                            this.currentValue = this.dictionary.entries[this.index].value;
//                            ++this.index;
//                            return true;
//                        }
//                    }
//                    this.index = this.dictionary.count + 1;
//                    this.currentValue = default(TValue);
//                    return false;
//                }

//                void IEnumerator.Reset()
//                {
//                    if (this.version != this.dictionary.version)
//                        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
//                    this.index = 0;
//                    this.currentValue = default(TValue);
//                }
//            }
//        }
//    }


//}

